程序员练级攻略：系统知识-[2026重制版]

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
 
// 多进程示例：父子进程协作
int main() {
    pid_t pid = fork();
 
    if (pid < 0) {
        // fork失败
        perror("fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Child process (PID: %d)\n", getpid());
        printf("Parent PID: %d\n", getppid());
 
        // 子进程执行的任务
        for (int i = 0; i < 3; i++) {
            printf("Child working... %d\n", i);
            sleep(1);
        }
 
        _exit(0);  // 子进程用_exit退出
    } else {
        // 父进程
        printf("Parent process (PID: %d)\n", getpid());
        printf("Created child with PID: %d\n", pid);
 
        // 等待子进程结束
        int status;
        waitpid(pid, &status, 0);
 
        if (WIFEXITED(status)) {
            printf("Child exited with status %d\n", WEXITSTATUS(status));
        }
 
        printf("Parent done.\n");
    }
 
    return 0;
}

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
 
#define THREAD_COUNT 4
 
// 共享资源
int counter = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
void* thread_func(void* arg) {
    int thread_id = *(int*)arg;
 
    for (int i = 0; i < 100000; i++) {
        // 加锁保护共享资源
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
 
    printf("Thread %d done.\n", thread_id);
    return NULL;
}
 
int main() {
    pthread_t threads[THREAD_COUNT];
    int ids[THREAD_COUNT];
 
    // 创建线程
    for (int i = 0; i < THREAD_COUNT; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, thread_func, &ids[i]);
    }
 
    // 等待所有线程结束
    for (int i = 0; i < THREAD_COUNT; i++) {
        pthread_join(threads[i], NULL);
    }
 
    printf("Final counter value: %d (expected: %d)\n",
           counter, THREAD_COUNT * 100000);
 
    pthread_mutex_destroy(&mutex);
    return 0;
}

#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_EVENTS 64
#define PORT 8080
 
// 设置非阻塞IO
int set_nonblocking(int fd) {
    int flags = fcntl(fd, F_GETFL, 0);
    return fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}
 
int main() {
    // 创建监听socket
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    set_nonblocking(listen_fd);
 
    int opt = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
 
    struct sockaddr_in addr = {
        .sin_family = AF_INET,
        .sin_addr.s_addr = INADDR_ANY,
        .sin_port = htons(PORT)
    };
    bind(listen_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(listen_fd, SOMAXCONN);
 
    // 创建epoll实例
    int epfd = epoll_create1(0);
 
    // 添加监听socket到epoll
    struct epoll_event ev = {
        .events = EPOLLIN,
        .data.fd = listen_fd
    };
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);
 
    struct epoll_event events[MAX_EVENTS];
 
    printf("Server running on port %d...\n", PORT);
 
    while (1) {
        // 等待事件（无限期阻塞）
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
 
        for (int i = 0; i < nfds; i++) {
            uint32_t evts = events[i].events;
            int fd = events[i].data.fd;
 
            if (fd == listen_fd) {
                // 新连接到来
                while (1) {
                    struct sockaddr_in client_addr;
                    socklen_t client_len = sizeof(client_addr);
                    int conn_fd = accept(listen_fd,
                        (struct sockaddr*)&client_addr, &client_len);
 
                    if (conn_fd == -1) {
                        break;  // 没有更多连接
                    }
 
                    set_nonblocking(conn_fd);
 
                    // 将新连接加入epoll（ET模式）
                    ev.events = EPOLLIN | EPOLLET;
                    ev.data.fd = conn_fd;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, conn_fd, &ev);
 
                    printf("New connection: %d\n", conn_fd);
                }
            } else {
                // 已有连接可读
                char buf[4096];
                ssize_t n = read(fd, buf, sizeof(buf));
 
                if (n <= 0) {
                    // 连接关闭或出错
                    close(fd);
                    epoll_ctl(epoll, EPOLL_CTL_DEL, fd, NULL);
                    printf("Connection %d closed\n", fd);
                } else {
                    // Echo back
                    write(fd, buf, n);
                }
            }
        }
    }
 
    close(epfd);
    close(listen_fd);
    return 0;
}

// io_uring 基本使用示例（概念性代码）
#include <liburing.h>
 
int main() {
    struct io_uring ring;
 
    // 初始化io_uring实例（256个entry）
    io_uring_queue_init(256, &ring, 0);
 
    // 获取一个submission queue entry
    struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
 
    // 准备一个读操作（异步）
    char buf[4096];
    io_uring_prep_read(sqe, fd, buf, sizeof(buf), 0);
 
    // 设置完成后回调
    io_uring_sqe_set_data(sqe, (void*)"read operation");
 
    // 提交请求
    io_uring_submit(&ring);
 
    // 等待完成
    struct io_uring_cqe *cqe;
    io_uring_wait_cqe(&ring, &cqe);
 
    // 处理结果
    if (cqe->res >= 0) {
        printf("Read %d bytes\n", cqe->res);
    } else {
        printf("Error: %s\n", strerror(-cqe->res));
    }
 
    io_uring_cqe_seen(&ring, cqe);
    io_uring_queue_exit(&ring);
    return 0;
}